home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / awt / DefaultKeyboardFocusManager.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  12.7 KB  |  772 lines
  1. package java.awt;
  2.  
  3. import java.awt.event.FocusEvent;
  4. import java.awt.event.KeyEvent;
  5. import java.awt.event.WindowEvent;
  6. import java.awt.peer.ComponentPeer;
  7. import java.awt.peer.LightweightPeer;
  8. import java.util.Iterator;
  9. import java.util.LinkedList;
  10. import java.util.List;
  11. import java.util.ListIterator;
  12. import java.util.Set;
  13. import java.util.logging.Level;
  14. import java.util.logging.Logger;
  15. import sun.awt.AppContext;
  16. import sun.awt.CausedFocusEvent;
  17. import sun.awt.SunToolkit;
  18. import sun.awt.CausedFocusEvent.Cause;
  19.  
  20. public class DefaultKeyboardFocusManager extends KeyboardFocusManager {
  21.    private static final Logger focusLog = Logger.getLogger("java.awt.focus.DefaultKeyboardFocusManager");
  22.    private Window realOppositeWindow;
  23.    private Component realOppositeComponent;
  24.    private int inSendMessage;
  25.    private LinkedList enqueuedKeyEvents = new LinkedList();
  26.    private LinkedList typeAheadMarkers = new LinkedList();
  27.    private boolean consumeNextKeyTyped;
  28.  
  29.    private Window getOwningFrameDialog(Window var1) {
  30.       while(var1 != null && !(var1 instanceof Frame) && !(var1 instanceof Dialog)) {
  31.          var1 = (Window)var1.getParent();
  32.       }
  33.  
  34.       return var1;
  35.    }
  36.  
  37.    private void restoreFocus(FocusEvent var1, Window var2) {
  38.       Component var3 = this.realOppositeComponent;
  39.       Component var4 = var1.getComponent();
  40.       if ((var2 == null || !this.restoreFocus(var2, var4, false)) && (var3 == null || !this.doRestoreFocus(var3, var4, false)) && (var1.getOppositeComponent() == null || !this.doRestoreFocus(var1.getOppositeComponent(), var4, false))) {
  41.          this.clearGlobalFocusOwner();
  42.       }
  43.  
  44.    }
  45.  
  46.    private void restoreFocus(WindowEvent var1) {
  47.       Window var2 = this.realOppositeWindow;
  48.       if ((var2 == null || !this.restoreFocus(var2, (Component)null, false)) && (var1.getOppositeWindow() == null || !this.restoreFocus(var1.getOppositeWindow(), (Component)null, false))) {
  49.          this.clearGlobalFocusOwner();
  50.       }
  51.  
  52.    }
  53.  
  54.    private boolean restoreFocus(Window var1, Component var2, boolean var3) {
  55.       Component var4 = KeyboardFocusManager.getMostRecentFocusOwner(var1);
  56.       if (var4 != null && var4 != var2 && this.doRestoreFocus(var4, var2, false)) {
  57.          return true;
  58.       } else if (var3) {
  59.          this.clearGlobalFocusOwner();
  60.          return true;
  61.       } else {
  62.          return false;
  63.       }
  64.    }
  65.  
  66.    private boolean restoreFocus(Component var1, boolean var2) {
  67.       return this.doRestoreFocus(var1, (Component)null, var2);
  68.    }
  69.  
  70.    private boolean doRestoreFocus(Component var1, Component var2, boolean var3) {
  71.       if (var1.isShowing() && var1.isFocusable() && var1.requestFocus(false, Cause.ROLLBACK)) {
  72.          return true;
  73.       } else {
  74.          Component var4 = var1.preNextFocusHelper();
  75.          if (var4 != var2 && Component.postNextFocusHelper(var4)) {
  76.             return true;
  77.          } else if (var3) {
  78.             this.clearGlobalFocusOwner();
  79.             return true;
  80.          } else {
  81.             return false;
  82.          }
  83.       }
  84.    }
  85.  
  86.    static boolean sendMessage(Component var0, AWTEvent var1) {
  87.       var1.isPosted = true;
  88.       AppContext var2 = AppContext.getAppContext();
  89.       AppContext var3 = var0.appContext;
  90.       DefaultKeyboardFocusManagerSentEvent var4 = new DefaultKeyboardFocusManagerSentEvent(var1, var2);
  91.       if (var2 == var3) {
  92.          ((SentEvent)var4).dispatch();
  93.       } else {
  94.          if (var3.isDisposed()) {
  95.             return false;
  96.          }
  97.  
  98.          SunToolkit.postEvent(var3, var4);
  99.          if (EventQueue.isDispatchThread()) {
  100.             EventDispatchThread var5 = (EventDispatchThread)Thread.currentThread();
  101.             var5.pumpEvents(1007, new 1(var4, var3));
  102.          } else {
  103.             synchronized(var4) {
  104.                while(!var4.dispatched && !var3.isDisposed()) {
  105.                   try {
  106.                      var4.wait(1000L);
  107.                   } catch (InterruptedException var8) {
  108.                      break;
  109.                   }
  110.                }
  111.             }
  112.          }
  113.       }
  114.  
  115.       return var4.dispatched;
  116.    }
  117.  
  118.    public boolean dispatchEvent(AWTEvent var1) {
  119.       if (focusLog.isLoggable(Level.FINE) && (var1 instanceof WindowEvent || var1 instanceof FocusEvent)) {
  120.          focusLog.fine("" + var1);
  121.       }
  122.  
  123.       switch (var1.getID()) {
  124.          case 205:
  125.             WindowEvent var16 = (WindowEvent)var1;
  126.             Window var21 = this.getGlobalActiveWindow();
  127.             Window var25 = var16.getWindow();
  128.             if (var21 != var25) {
  129.                if (var21 != null) {
  130.                   boolean var29 = sendMessage(var21, new WindowEvent(var21, 206, var25));
  131.                   if (!var29) {
  132.                      this.setGlobalActiveWindow((Window)null);
  133.                   }
  134.  
  135.                   if (this.getGlobalActiveWindow() != null) {
  136.                      return true;
  137.                   }
  138.                }
  139.  
  140.                this.setGlobalActiveWindow(var25);
  141.                if (var25 == this.getGlobalActiveWindow()) {
  142.                   return this.typeAheadAssertions(var25, var16);
  143.                }
  144.             }
  145.             break;
  146.          case 206:
  147.             WindowEvent var15 = (WindowEvent)var1;
  148.             Window var20 = this.getGlobalActiveWindow();
  149.             if (var20 != null && var20 == var1.getSource()) {
  150.                this.setGlobalActiveWindow((Window)null);
  151.                if (this.getGlobalActiveWindow() == null) {
  152.                   var15.setSource(var20);
  153.                   return this.typeAheadAssertions(var20, var15);
  154.                }
  155.             }
  156.             break;
  157.          case 207:
  158.             WindowEvent var14 = (WindowEvent)var1;
  159.             Window var19 = this.getGlobalFocusedWindow();
  160.             Window var24 = var14.getWindow();
  161.             if (var24 != var19) {
  162.                if (var19 != null) {
  163.                   boolean var27 = sendMessage(var19, new WindowEvent(var19, 208, var24));
  164.                   if (!var27) {
  165.                      this.setGlobalFocusOwner((Component)null);
  166.                      this.setGlobalFocusedWindow((Window)null);
  167.                   }
  168.                }
  169.  
  170.                Window var28 = this.getOwningFrameDialog(var24);
  171.                Window var32 = this.getGlobalActiveWindow();
  172.                if (var28 != var32) {
  173.                   sendMessage(var28, new WindowEvent(var28, 205, var32));
  174.                   if (var28 != this.getGlobalActiveWindow()) {
  175.                      this.restoreFocus(var14);
  176.                      return true;
  177.                   }
  178.                }
  179.  
  180.                this.setGlobalFocusedWindow(var24);
  181.                if (var24 == this.getGlobalFocusedWindow()) {
  182.                   this.setNativeFocusedWindow(var24);
  183.                   if (this.inSendMessage == 0) {
  184.                      Component var34 = KeyboardFocusManager.getMostRecentFocusOwner(var24);
  185.                      if (var34 == null && var24.isFocusableWindow()) {
  186.                         var34 = var24.getFocusTraversalPolicy().getInitialComponent(var24);
  187.                      }
  188.  
  189.                      Object var37 = null;
  190.                      Component var38;
  191.                      synchronized(KeyboardFocusManager.class) {
  192.                         var38 = var24.setTemporaryLostComponent((Component)null);
  193.                      }
  194.  
  195.                      if (focusLog.isLoggable(Level.FINER)) {
  196.                         focusLog.log(Level.FINER, "tempLost {0}, toFocus {1}", new Object[]{var38, var34});
  197.                      }
  198.  
  199.                      if (var38 != null) {
  200.                         var38.requestFocusInWindow(Cause.ACTIVATION);
  201.                      }
  202.  
  203.                      if (var34 != null && var34 != var38) {
  204.                         var34.requestFocusInWindow(Cause.ACTIVATION);
  205.                      }
  206.                   }
  207.  
  208.                   Window var35 = this.realOppositeWindow;
  209.                   if (var35 != var14.getOppositeWindow()) {
  210.                      var14 = new WindowEvent(var24, 207, var35);
  211.                   }
  212.  
  213.                   return this.typeAheadAssertions(var24, var14);
  214.                }
  215.  
  216.                this.restoreFocus(var14);
  217.             }
  218.             break;
  219.          case 208:
  220.             WindowEvent var13 = (WindowEvent)var1;
  221.             Window var18 = this.getGlobalFocusedWindow();
  222.             Window var23 = var13.getWindow();
  223.             Window var26 = this.getGlobalActiveWindow();
  224.             Window var31 = var13.getOppositeWindow();
  225.             if (focusLog.isLoggable(Level.FINE)) {
  226.                focusLog.log(Level.FINE, "Active {0}, Current focused {1}, losing focus {2} opposite {3}", new Object[]{var26, var18, var23, var31});
  227.             }
  228.  
  229.             if (var18 != null && (this.inSendMessage != 0 || var23 != var26 || var31 != var18)) {
  230.                Component var33 = this.getGlobalFocusOwner();
  231.                if (var33 != null) {
  232.                   Object var36 = null;
  233.                   if (var31 != null) {
  234.                      var36 = var31.getTemporaryLostComponent();
  235.                      if (var36 == null) {
  236.                         var36 = var31.getMostRecentFocusOwner();
  237.                      }
  238.                   }
  239.  
  240.                   if (var36 == null) {
  241.                      var36 = var31;
  242.                   }
  243.  
  244.                   sendMessage(var33, new CausedFocusEvent(var33, 1005, true, (Component)var36, Cause.ACTIVATION));
  245.                }
  246.  
  247.                this.setGlobalFocusedWindow((Window)null);
  248.                if (this.getGlobalFocusedWindow() != null) {
  249.                   this.restoreFocus(var18, (Component)null, true);
  250.                } else {
  251.                   this.setNativeFocusedWindow((Window)null);
  252.                   var13.setSource(var18);
  253.                   this.realOppositeWindow = var31 != null ? var18 : null;
  254.                   this.typeAheadAssertions(var18, var13);
  255.                   if (var31 == null) {
  256.                      sendMessage(var26, new WindowEvent(var26, 206, (Window)null));
  257.                      if (this.getGlobalActiveWindow() != null) {
  258.                         this.restoreFocus(var18, (Component)null, true);
  259.                      }
  260.                   }
  261.                }
  262.             }
  263.             break;
  264.          case 400:
  265.          case 401:
  266.          case 402:
  267.             return this.typeAheadAssertions((Component)null, var1);
  268.          case 1004:
  269.             Object var12 = (FocusEvent)var1;
  270.             CausedFocusEvent.Cause var17 = var12 instanceof CausedFocusEvent ? ((CausedFocusEvent)var12).getCause() : Cause.UNKNOWN;
  271.             Component var22 = this.getGlobalFocusOwner();
  272.             Component var5 = ((FocusEvent)var12).getComponent();
  273.             if (var22 == var5) {
  274.                if (focusLog.isLoggable(Level.FINE)) {
  275.                   focusLog.log(Level.FINE, "Skipping {0} because focus owner is the same", new Object[]{var1});
  276.                }
  277.  
  278.                this.dequeueKeyEvents(-1L, var5);
  279.             } else {
  280.                if (var22 != null) {
  281.                   boolean var6 = sendMessage(var22, new CausedFocusEvent(var22, 1005, ((FocusEvent)var12).isTemporary(), var5, var17));
  282.                   if (!var6) {
  283.                      this.setGlobalFocusOwner((Component)null);
  284.                      if (!((FocusEvent)var12).isTemporary()) {
  285.                         this.setGlobalPermanentFocusOwner((Component)null);
  286.                      }
  287.                   }
  288.                }
  289.  
  290.                Object var30;
  291.                for(var30 = var5; var30 != null && !(var30 instanceof Window); var30 = ((Component)var30).parent) {
  292.                }
  293.  
  294.                Window var7 = this.getGlobalFocusedWindow();
  295.                if (var30 != null && var30 != var7) {
  296.                   sendMessage((Component)var30, new WindowEvent((Window)var30, 207, var7));
  297.                   if (var30 != this.getGlobalFocusedWindow()) {
  298.                      this.dequeueKeyEvents(-1L, var5);
  299.                      break;
  300.                   }
  301.                }
  302.  
  303.                this.setGlobalFocusOwner(var5);
  304.                if (var5 != this.getGlobalFocusOwner()) {
  305.                   this.dequeueKeyEvents(-1L, var5);
  306.                   this.restoreFocus((FocusEvent)var12, (Window)var30);
  307.                } else {
  308.                   if (!((FocusEvent)var12).isTemporary()) {
  309.                      this.setGlobalPermanentFocusOwner(var5);
  310.                      if (var5 != this.getGlobalPermanentFocusOwner()) {
  311.                         this.dequeueKeyEvents(-1L, var5);
  312.                         this.restoreFocus((FocusEvent)var12, (Window)var30);
  313.                         break;
  314.                      }
  315.                   }
  316.  
  317.                   this.setNativeFocusOwner(getHeavyweight(var5));
  318.                   Component var8 = this.realOppositeComponent;
  319.                   if (var8 != null && var8 != ((FocusEvent)var12).getOppositeComponent()) {
  320.                      var12 = new CausedFocusEvent(var5, 1004, ((FocusEvent)var12).isTemporary(), var8, var17);
  321.                      ((AWTEvent)var12).isPosted = true;
  322.                   }
  323.  
  324.                   return this.typeAheadAssertions(var5, (AWTEvent)var12);
  325.                }
  326.             }
  327.             break;
  328.          case 1005:
  329.             FocusEvent var2 = (FocusEvent)var1;
  330.             Component var3 = this.getGlobalFocusOwner();
  331.             if (var3 == null) {
  332.                if (focusLog.isLoggable(Level.FINE)) {
  333.                   focusLog.log(Level.FINE, "Skipping {0} because focus owner is null", new Object[]{var1});
  334.                }
  335.             } else if (var3 == var2.getOppositeComponent()) {
  336.                if (focusLog.isLoggable(Level.FINE)) {
  337.                   focusLog.log(Level.FINE, "Skipping {0} because current focus owner is equal to opposite", new Object[]{var1});
  338.                }
  339.             } else {
  340.                this.setGlobalFocusOwner((Component)null);
  341.                if (this.getGlobalFocusOwner() != null) {
  342.                   this.restoreFocus(var3, true);
  343.                } else {
  344.                   if (!var2.isTemporary()) {
  345.                      this.setGlobalPermanentFocusOwner((Component)null);
  346.                      if (this.getGlobalPermanentFocusOwner() != null) {
  347.                         this.restoreFocus(var3, true);
  348.                         break;
  349.                      }
  350.                   } else {
  351.                      Window var4 = var3.getContainingWindow();
  352.                      if (var4 != null) {
  353.                         var4.setTemporaryLostComponent(var3);
  354.                      }
  355.                   }
  356.  
  357.                   this.setNativeFocusOwner((Component)null);
  358.                   var2.setSource(var3);
  359.                   this.realOppositeComponent = var2.getOppositeComponent() != null ? var3 : null;
  360.                   return this.typeAheadAssertions(var3, var2);
  361.                }
  362.             }
  363.             break;
  364.          default:
  365.             return false;
  366.       }
  367.  
  368.       return true;
  369.    }
  370.  
  371.    public boolean dispatchKeyEvent(KeyEvent var1) {
  372.       Component var2 = var1.isPosted ? this.getFocusOwner() : var1.getComponent();
  373.       if (var2 != null && var2.isShowing() && var2.isFocusable() && var2.isEnabled() && !var1.isConsumed()) {
  374.          Component var3 = var1.getComponent();
  375.          if (var3 != null && var3.isEnabled()) {
  376.             this.redispatchEvent(var3, var1);
  377.          }
  378.       }
  379.  
  380.       boolean var8 = false;
  381.       List var4 = this.getKeyEventPostProcessors();
  382.       if (var4 != null) {
  383.          for(Iterator var5 = var4.iterator(); !var8 && var5.hasNext(); var8 = ((KeyEventPostProcessor)((KeyEventPostProcessor)var5.next())).postProcessKeyEvent(var1)) {
  384.          }
  385.       }
  386.  
  387.       if (!var8) {
  388.          this.postProcessKeyEvent(var1);
  389.       }
  390.  
  391.       Component var9 = var1.getComponent();
  392.       ComponentPeer var6 = var9.getPeer();
  393.       if (var6 == null || var6 instanceof LightweightPeer) {
  394.          Container var7 = var9.getNativeContainer();
  395.          if (var7 != null) {
  396.             var6 = var7.getPeer();
  397.          }
  398.       }
  399.  
  400.       if (var6 != null) {
  401.          var6.handleEvent(var1);
  402.       }
  403.  
  404.       return true;
  405.    }
  406.  
  407.    public boolean postProcessKeyEvent(KeyEvent var1) {
  408.       if (!var1.isConsumed()) {
  409.          Component var2 = var1.getComponent();
  410.          Container var3 = (Container)(var2 instanceof Container ? var2 : var2.getParent());
  411.          if (var3 != null) {
  412.             var3.postProcessKeyEvent(var1);
  413.          }
  414.       }
  415.  
  416.       return true;
  417.    }
  418.  
  419.    private void pumpApprovedKeyEvents() {
  420.       KeyEvent var1;
  421.       do {
  422.          var1 = null;
  423.          synchronized(this) {
  424.             if (this.enqueuedKeyEvents.size() != 0) {
  425.                var1 = (KeyEvent)this.enqueuedKeyEvents.getFirst();
  426.                if (this.typeAheadMarkers.size() != 0) {
  427.                   TypeAheadMarker var3 = (TypeAheadMarker)this.typeAheadMarkers.getFirst();
  428.                   if (var1.getWhen() > var3.after) {
  429.                      var1 = null;
  430.                   }
  431.                }
  432.  
  433.                if (var1 != null) {
  434.                   focusLog.log(Level.FINER, "Pumping approved event {0}", new Object[]{var1});
  435.                   this.enqueuedKeyEvents.removeFirst();
  436.                }
  437.             }
  438.          }
  439.  
  440.          if (var1 != null) {
  441.             this.preDispatchKeyEvent(var1);
  442.          }
  443.       } while(var1 != null);
  444.  
  445.    }
  446.  
  447.    void dumpMarkers() {
  448.       if (focusLog.isLoggable(Level.FINEST)) {
  449.          focusLog.log(Level.FINEST, ">>> Markers dump, time: {0}", System.currentTimeMillis());
  450.          synchronized(this) {
  451.             if (this.typeAheadMarkers.size() != 0) {
  452.                for(TypeAheadMarker var3 : this.typeAheadMarkers) {
  453.                   focusLog.log(Level.FINEST, "    {0}", var3);
  454.                }
  455.             }
  456.          }
  457.       }
  458.  
  459.    }
  460.  
  461.    private boolean typeAheadAssertions(Component var1, AWTEvent var2) {
  462.       this.pumpApprovedKeyEvents();
  463.       switch (var2.getID()) {
  464.          case 400:
  465.          case 401:
  466.          case 402:
  467.             KeyEvent var3 = (KeyEvent)var2;
  468.             synchronized(this) {
  469.                if (var2.isPosted && this.typeAheadMarkers.size() != 0) {
  470.                   TypeAheadMarker var10 = (TypeAheadMarker)this.typeAheadMarkers.getFirst();
  471.                   if (var3.getWhen() > var10.after) {
  472.                      focusLog.log(Level.FINER, "Storing event {0} because of marker {1}", new Object[]{var3, var10});
  473.                      this.enqueuedKeyEvents.addLast(var3);
  474.                      return true;
  475.                   }
  476.                }
  477.             }
  478.  
  479.             return this.preDispatchKeyEvent(var3);
  480.          case 1004:
  481.             focusLog.log(Level.FINEST, "Markers before FOCUS_GAINED on {0}", new Object[]{var1});
  482.             this.dumpMarkers();
  483.             synchronized(this) {
  484.                boolean var4 = false;
  485.                if (this.hasMarker(var1)) {
  486.                   for(Iterator var5 = this.typeAheadMarkers.iterator(); var5.hasNext(); var5.remove()) {
  487.                      if (((TypeAheadMarker)var5.next()).untilFocused == var1) {
  488.                         var4 = true;
  489.                      } else if (var4) {
  490.                         break;
  491.                      }
  492.                   }
  493.                } else {
  494.                   focusLog.log(Level.FINER, "Event without marker {0}", var2);
  495.                }
  496.             }
  497.  
  498.             focusLog.log(Level.FINEST, "Markers after FOCUS_GAINED");
  499.             this.dumpMarkers();
  500.             this.redispatchEvent(var1, var2);
  501.             this.pumpApprovedKeyEvents();
  502.             return true;
  503.          default:
  504.             this.redispatchEvent(var1, var2);
  505.             return true;
  506.       }
  507.    }
  508.  
  509.    private boolean hasMarker(Component var1) {
  510.       Iterator var2 = this.typeAheadMarkers.iterator();
  511.  
  512.       while(var2.hasNext()) {
  513.          if (((TypeAheadMarker)var2.next()).untilFocused == var1) {
  514.             return true;
  515.          }
  516.       }
  517.  
  518.       return false;
  519.    }
  520.  
  521.    void clearMarkers() {
  522.       synchronized(this) {
  523.          this.typeAheadMarkers.clear();
  524.       }
  525.    }
  526.  
  527.    private boolean preDispatchKeyEvent(KeyEvent var1) {
  528.       if (var1.isPosted) {
  529.          Component var2 = this.getFocusOwner();
  530.          var1.setSource(var2 != null ? var2 : this.getFocusedWindow());
  531.       }
  532.  
  533.       if (var1.getSource() == null) {
  534.          return true;
  535.       } else {
  536.          EventQueue.setCurrentEventAndMostRecentTime(var1);
  537.          if (KeyboardFocusManager.isProxyActive(var1)) {
  538.             Component var6 = (Component)var1.getSource();
  539.             Container var7 = var6.getNativeContainer();
  540.             if (var7 != null) {
  541.                ComponentPeer var4 = var7.getPeer();
  542.                if (var4 != null) {
  543.                   var4.handleEvent(var1);
  544.                   var1.consume();
  545.                }
  546.             }
  547.  
  548.             return true;
  549.          } else {
  550.             List var5 = this.getKeyEventDispatchers();
  551.             if (var5 != null) {
  552.                Iterator var3 = var5.iterator();
  553.  
  554.                while(var3.hasNext()) {
  555.                   if (((KeyEventDispatcher)((KeyEventDispatcher)var3.next())).dispatchKeyEvent(var1)) {
  556.                      return true;
  557.                   }
  558.                }
  559.             }
  560.  
  561.             return this.dispatchKeyEvent(var1);
  562.          }
  563.       }
  564.    }
  565.  
  566.    private void consumeNextKeyTyped(KeyEvent var1) {
  567.       this.consumeNextKeyTyped = true;
  568.    }
  569.  
  570.    private void consumeTraversalKey(KeyEvent var1) {
  571.       var1.consume();
  572.       this.consumeNextKeyTyped = var1.getID() == 401 && !var1.isActionKey();
  573.    }
  574.  
  575.    private boolean consumeProcessedKeyEvent(KeyEvent var1) {
  576.       if (var1.getID() == 400 && this.consumeNextKeyTyped) {
  577.          var1.consume();
  578.          this.consumeNextKeyTyped = false;
  579.          return true;
  580.       } else {
  581.          return false;
  582.       }
  583.    }
  584.  
  585.    public void processKeyEvent(Component var1, KeyEvent var2) {
  586.       if (!this.consumeProcessedKeyEvent(var2)) {
  587.          if (var2.getID() != 400) {
  588.             if (var1.getFocusTraversalKeysEnabled() && !var2.isConsumed()) {
  589.                AWTKeyStroke var3 = AWTKeyStroke.getAWTKeyStrokeForEvent(var2);
  590.                AWTKeyStroke var4 = AWTKeyStroke.getAWTKeyStroke(var3.getKeyCode(), var3.getModifiers(), !var3.isOnKeyRelease());
  591.                Set var5 = var1.getFocusTraversalKeys(0);
  592.                boolean var6 = var5.contains(var3);
  593.                boolean var7 = var5.contains(var4);
  594.                if (!var6 && !var7) {
  595.                   var5 = var1.getFocusTraversalKeys(1);
  596.                   var6 = var5.contains(var3);
  597.                   var7 = var5.contains(var4);
  598.                   if (!var6 && !var7) {
  599.                      var5 = var1.getFocusTraversalKeys(2);
  600.                      var6 = var5.contains(var3);
  601.                      var7 = var5.contains(var4);
  602.                      if (!var6 && !var7) {
  603.                         if (var1 instanceof Container && ((Container)var1).isFocusCycleRoot()) {
  604.                            var5 = var1.getFocusTraversalKeys(3);
  605.                            var6 = var5.contains(var3);
  606.                            var7 = var5.contains(var4);
  607.                            if (var6 || var7) {
  608.                               this.consumeTraversalKey(var2);
  609.                               if (var6) {
  610.                                  this.downFocusCycle((Container)var1);
  611.                                  return;
  612.                               }
  613.                            }
  614.  
  615.                         }
  616.                      } else {
  617.                         this.consumeTraversalKey(var2);
  618.                         if (var6) {
  619.                            this.upFocusCycle(var1);
  620.                         }
  621.  
  622.                      }
  623.                   } else {
  624.                      this.consumeTraversalKey(var2);
  625.                      if (var6) {
  626.                         this.focusPreviousComponent(var1);
  627.                      }
  628.  
  629.                   }
  630.                } else {
  631.                   this.consumeTraversalKey(var2);
  632.                   if (var6) {
  633.                      this.focusNextComponent(var1);
  634.                   }
  635.  
  636.                }
  637.             }
  638.          }
  639.       }
  640.    }
  641.  
  642.    protected synchronized void enqueueKeyEvents(long var1, Component var3) {
  643.       if (var3 != null) {
  644.          focusLog.log(Level.FINER, "Enqueue at {0} for {1}", new Object[]{var1, var3});
  645.          int var4 = 0;
  646.          int var5 = this.typeAheadMarkers.size();
  647.  
  648.          for(ListIterator var6 = this.typeAheadMarkers.listIterator(var5); var5 > 0; --var5) {
  649.             TypeAheadMarker var7 = (TypeAheadMarker)var6.previous();
  650.             if (var7.after <= var1) {
  651.                var4 = var5;
  652.                break;
  653.             }
  654.          }
  655.  
  656.          this.typeAheadMarkers.add(var4, new TypeAheadMarker(var1, var3));
  657.       }
  658.    }
  659.  
  660.    protected synchronized void dequeueKeyEvents(long var1, Component var3) {
  661.       if (var3 != null) {
  662.          focusLog.log(Level.FINER, "Dequeue at {0} for {1}", new Object[]{var1, var3});
  663.          ListIterator var5 = this.typeAheadMarkers.listIterator(var1 >= 0L ? this.typeAheadMarkers.size() : 0);
  664.          if (var1 < 0L) {
  665.             while(var5.hasNext()) {
  666.                TypeAheadMarker var6 = (TypeAheadMarker)var5.next();
  667.                if (var6.untilFocused == var3) {
  668.                   var5.remove();
  669.                   return;
  670.                }
  671.             }
  672.          } else {
  673.             while(var5.hasPrevious()) {
  674.                TypeAheadMarker var4 = (TypeAheadMarker)var5.previous();
  675.                if (var4.untilFocused == var3 && var4.after == var1) {
  676.                   var5.remove();
  677.                   return;
  678.                }
  679.             }
  680.          }
  681.  
  682.       }
  683.    }
  684.  
  685.    protected synchronized void discardKeyEvents(Component var1) {
  686.       if (var1 != null) {
  687.          long var2 = -1L;
  688.          Iterator var4 = this.typeAheadMarkers.iterator();
  689.  
  690.          while(var4.hasNext()) {
  691.             TypeAheadMarker var5 = (TypeAheadMarker)var4.next();
  692.             Object var6 = var5.untilFocused;
  693.  
  694.             boolean var7;
  695.             for(var7 = var6 == var1; !var7 && var6 != null && !(var6 instanceof Window); var7 = var6 == var1) {
  696.                var6 = ((Component)var6).getParent();
  697.             }
  698.  
  699.             if (var7) {
  700.                if (var2 < 0L) {
  701.                   var2 = var5.after;
  702.                }
  703.  
  704.                var4.remove();
  705.             } else if (var2 >= 0L) {
  706.                this.purgeStampedEvents(var2, var5.after);
  707.                var2 = -1L;
  708.             }
  709.          }
  710.  
  711.          this.purgeStampedEvents(var2, -1L);
  712.       }
  713.    }
  714.  
  715.    private void purgeStampedEvents(long var1, long var3) {
  716.       if (var1 >= 0L) {
  717.          Iterator var5 = this.enqueuedKeyEvents.iterator();
  718.  
  719.          while(var5.hasNext()) {
  720.             KeyEvent var6 = (KeyEvent)var5.next();
  721.             long var7 = var6.getWhen();
  722.             if (var1 < var7 && (var3 < 0L || var7 <= var3)) {
  723.                var5.remove();
  724.             }
  725.  
  726.             if (var3 >= 0L && var7 > var3) {
  727.                break;
  728.             }
  729.          }
  730.  
  731.       }
  732.    }
  733.  
  734.    public void focusPreviousComponent(Component var1) {
  735.       if (var1 != null) {
  736.          var1.transferFocusBackward();
  737.       }
  738.  
  739.    }
  740.  
  741.    public void focusNextComponent(Component var1) {
  742.       if (var1 != null) {
  743.          var1.transferFocus();
  744.       }
  745.  
  746.    }
  747.  
  748.    public void upFocusCycle(Component var1) {
  749.       if (var1 != null) {
  750.          var1.transferFocusUpCycle();
  751.       }
  752.  
  753.    }
  754.  
  755.    public void downFocusCycle(Container var1) {
  756.       if (var1 != null && var1.isFocusCycleRoot()) {
  757.          var1.transferFocusDownCycle();
  758.       }
  759.  
  760.    }
  761.  
  762.    // $FF: synthetic method
  763.    static int access$008(DefaultKeyboardFocusManager var0) {
  764.       return var0.inSendMessage++;
  765.    }
  766.  
  767.    // $FF: synthetic method
  768.    static int access$010(DefaultKeyboardFocusManager var0) {
  769.       return var0.inSendMessage--;
  770.    }
  771. }
  772.